home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 21 / AACD 21.iso / AACD / Utilities / Ghostscript / src / gdevpdfi.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-01  |  19.4 KB  |  635 lines
  1. /* Copyright (C) 1996, 2000 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of AFPL Ghostscript.
  4.   
  5.   AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6.   distributor accepts any responsibility for the consequences of using it, or
  7.   for whether it serves any particular purpose or works at all, unless he or
  8.   she says so in writing.  Refer to the Aladdin Free Public License (the
  9.   "License") for full details.
  10.   
  11.   Every copy of AFPL Ghostscript must include a copy of the License, normally
  12.   in a plain ASCII text file named PUBLIC.  The License grants you the right
  13.   to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14.   conditions described in the License.  Among other things, the License
  15.   requires that the copyright notice and this notice be preserved on all
  16.   copies.
  17. */
  18.  
  19. /*$Id: gdevpdfi.c,v 1.20 2000/09/19 19:00:17 lpd Exp $ */
  20. /* Image handling for PDF-writing driver */
  21. #include "gx.h"
  22. #include "gserrors.h"
  23. #include "gsdevice.h"
  24. #include "gsflip.h"
  25. #include "gdevpdfx.h"
  26. #include "gdevpdfg.h"
  27. #include "gdevpdfo.h"        /* for data stream */
  28. #include "gxcspace.h"
  29. #include "gximage3.h"
  30. #include "gximag3x.h"
  31. #include "gsiparm4.h"
  32.  
  33. /* Forward references */
  34. private image_enum_proc_plane_data(pdf_image_plane_data);
  35. private image_enum_proc_end_image(pdf_image_end_image);
  36. private image_enum_proc_end_image(pdf_image_end_image_object);
  37. private IMAGE3_MAKE_MID_PROC(pdf_image3_make_mid);
  38. private IMAGE3_MAKE_MCDE_PROC(pdf_image3_make_mcde);
  39. private IMAGE3X_MAKE_MID_PROC(pdf_image3x_make_mid);
  40. private IMAGE3X_MAKE_MCDE_PROC(pdf_image3x_make_mcde);
  41.  
  42. private const gx_image_enum_procs_t pdf_image_enum_procs = {
  43.     pdf_image_plane_data,
  44.     pdf_image_end_image
  45. };
  46. private const gx_image_enum_procs_t pdf_image_object_enum_procs = {
  47.     pdf_image_plane_data,
  48.     pdf_image_end_image_object
  49. };
  50.  
  51. /* ---------------- Driver procedures ---------------- */
  52.  
  53. /* Define the structure for keeping track of progress through an image. */
  54. typedef struct pdf_image_enum_s {
  55.     gx_image_enum_common;
  56.     gs_memory_t *memory;
  57.     int width;
  58.     int bits_per_pixel;        /* bits per pixel (per plane) */
  59.     int rows_left;
  60.     pdf_image_writer writer;
  61.     gs_matrix mat;
  62. } pdf_image_enum;
  63. gs_private_st_composite(st_pdf_image_enum, pdf_image_enum, "pdf_image_enum",
  64.   pdf_image_enum_enum_ptrs, pdf_image_enum_reloc_ptrs);
  65. /* GC procedures */
  66. private ENUM_PTRS_WITH(pdf_image_enum_enum_ptrs, pdf_image_enum *pie)
  67.     if (index < pdf_image_writer_max_ptrs) {
  68.     gs_ptr_type_t ret =
  69.         ENUM_USING(st_pdf_image_writer, &pie->writer, sizeof(pie->writer),
  70.                index);
  71.  
  72.     if (ret == 0)        /* don't stop early */
  73.         ENUM_RETURN(0);
  74.     return ret;
  75.     }
  76.     return ENUM_USING_PREFIX(st_gx_image_enum_common,
  77.                  pdf_image_writer_max_ptrs);
  78. ENUM_PTRS_END
  79. private RELOC_PTRS_WITH(pdf_image_enum_reloc_ptrs, pdf_image_enum *pie)
  80. {
  81.     RELOC_USING(st_pdf_image_writer, &pie->writer, sizeof(pie->writer));
  82.     RELOC_USING(st_gx_image_enum_common, vptr, size);
  83. }
  84. RELOC_PTRS_END
  85.  
  86. /*
  87.  * Test whether we can write an image in-line.  Before PDF 1.2, this is only
  88.  * allowed for masks, images in built-in color spaces, and images in Indexed
  89.  * color spaces based on these with a string lookup table.
  90.  */
  91. private bool
  92. can_write_image_in_line(const gx_device_pdf *pdev, const gs_image_t *pim)
  93. {
  94.     const gs_color_space *pcs;
  95.  
  96.     if (pim->ImageMask)
  97.     return true;
  98.     if (pdev->CompatibilityLevel >= 1.2)
  99.     return true;
  100.     pcs = pim->ColorSpace;
  101.  cs:
  102.     switch (gs_color_space_get_index(pcs)) {
  103.     case gs_color_space_index_DeviceGray:
  104.     case gs_color_space_index_DeviceRGB:
  105.     case gs_color_space_index_DeviceCMYK:
  106.     return true;
  107.     case gs_color_space_index_Indexed:
  108.     if (pcs->params.indexed.use_proc)
  109.         return false;
  110.     pcs = (const gs_color_space *)&pcs->params.indexed.base_space;
  111.     goto cs;
  112.     default:
  113.     return false;
  114.     }
  115. }
  116.  
  117. /*
  118.  * Start processing an image.  This procedure takes extra arguments because
  119.  * it has to do something slightly different for the parts of an ImageType 3
  120.  * image.
  121.  */
  122. typedef enum {
  123.     PDF_IMAGE_DEFAULT,
  124.     PDF_IMAGE_TYPE3_MASK,    /* no in-line, don't render */
  125.     PDF_IMAGE_TYPE3_DATA    /* no in-line */
  126. } pdf_typed_image_context_t;
  127. private int
  128. pdf_begin_typed_image(gx_device_pdf *pdev, const gs_imager_state * pis,
  129.               const gs_matrix *pmat, const gs_image_common_t *pic,
  130.               const gs_int_rect * prect,
  131.               const gx_drawing_color * pdcolor,
  132.               const gx_clip_path * pcpath, gs_memory_t * mem,
  133.               gx_image_enum_common_t ** pinfo,
  134.               pdf_typed_image_context_t context)
  135. {
  136.     const gs_pixel_image_t *pim;
  137.     int code;
  138.     pdf_image_enum *pie;
  139.     gs_image_format_t format;
  140.     const gs_color_space *pcs;
  141.     gs_color_space cs_gray_temp;
  142.     cos_value_t cs_value;
  143.     int num_components;
  144.     bool is_mask = false, in_line = false;
  145.     gs_int_rect rect;
  146.     /*
  147.      * We define this union because psdf_setup_image_filters may alter the
  148.      * gs_pixel_image_t part, but pdf_begin_image_data must also have access
  149.      * to the type-specific parameters.
  150.      */
  151.     union iu_ {
  152.     gs_pixel_image_t pixel;    /* we may change some components */
  153.     gs_image1_t type1;
  154.     gs_image3_t type3;
  155.     gs_image3x_t type3x;
  156.     gs_image4_t type4;
  157.     } image;
  158.     ulong nbytes;
  159.     int width, height;
  160.  
  161.     /* Check for the image types we can handle. */
  162.     switch (pic->type->index) {
  163.     case 1: {
  164.     const gs_image_t *pim1 = (const gs_image_t *)pic;
  165.  
  166.     if (pim1->Alpha != gs_image_alpha_none)
  167.         goto nyi;
  168.     is_mask = pim1->ImageMask;
  169.     in_line = context == PDF_IMAGE_DEFAULT &&
  170.         can_write_image_in_line(pdev, pim1);
  171.     image.type1 = *pim1;
  172.     break;
  173.     }
  174.     case 3: {
  175.     const gs_image3_t *pim3 = (const gs_image3_t *)pic;
  176.  
  177.     if (pdev->CompatibilityLevel < 1.3)
  178.         goto nyi;
  179.     if (prect && !(prect->p.x == 0 && prect->p.y == 0 &&
  180.                prect->q.x == pim3->Width &&
  181.                prect->q.y == pim3->Height))
  182.         goto nyi;
  183.     /*
  184.      * We handle ImageType 3 images in a completely different way:
  185.      * the default implementation sets up the enumerator.
  186.      */
  187.     return gx_begin_image3_generic((gx_device *)pdev, pis, pmat, pic,
  188.                        prect, pdcolor, pcpath, mem,
  189.                        pdf_image3_make_mid,
  190.                        pdf_image3_make_mcde, pinfo);
  191.     }
  192.     case IMAGE3X_IMAGETYPE: {
  193.     /* See ImageType3 above for more information. */
  194.     const gs_image3x_t *pim3x = (const gs_image3x_t *)pic;
  195.  
  196.     if (pdev->CompatibilityLevel < 1.4)
  197.         goto nyi;
  198.     if (prect && !(prect->p.x == 0 && prect->p.y == 0 &&
  199.                prect->q.x == pim3x->Width &&
  200.                prect->q.y == pim3x->Height))
  201.         goto nyi;
  202.     return gx_begin_image3x_generic((gx_device *)pdev, pis, pmat, pic,
  203.                     prect, pdcolor, pcpath, mem,
  204.                     pdf_image3x_make_mid,
  205.                     pdf_image3x_make_mcde, pinfo);
  206.     }
  207.     case 4:
  208.     if (pdev->CompatibilityLevel < 1.3)
  209.         goto nyi;
  210.     image.type4 = *(const gs_image4_t *)pic;
  211.     break;
  212.     default:
  213.     goto nyi;
  214.     }
  215.     pim = (const gs_pixel_image_t *)pic;
  216.     format = pim->format;
  217.     switch (format) {
  218.     case gs_image_format_chunky:
  219.     case gs_image_format_component_planar:
  220.     break;
  221.     default:
  222.     goto nyi;
  223.     }
  224.     pcs = pim->ColorSpace;
  225.     num_components = (is_mask ? 1 : gs_color_space_num_components(pcs));
  226.  
  227.     code = pdf_open_page(pdev, PDF_IN_STREAM);
  228.     if (code < 0)
  229.     return code;
  230.     if (context == PDF_IMAGE_TYPE3_MASK) {
  231.     /*
  232.      * The soft mask for an ImageType 3x image uses a DevicePixel
  233.      * color space, which pdf_color_space() can't handle.  Patch it
  234.      * to DeviceGray here.
  235.      */
  236.     gs_cspace_init_DeviceGray(&cs_gray_temp);
  237.     pcs = &cs_gray_temp;
  238.     } else if (is_mask)
  239.     code = pdf_prepare_imagemask(pdev, pis, pdcolor);
  240.     else
  241.     code = pdf_prepare_image(pdev, pis);
  242.     if (code < 0)
  243.     goto nyi;
  244.     if (prect)
  245.     rect = *prect;
  246.     else {
  247.     rect.p.x = rect.p.y = 0;
  248.     rect.q.x = pim->Width, rect.q.y = pim->Height;
  249.     }
  250.     pie = gs_alloc_struct(mem, pdf_image_enum, &st_pdf_image_enum,
  251.               "pdf_begin_image");
  252.     if (pie == 0)
  253.     return_error(gs_error_VMerror);
  254.     *pinfo = (gx_image_enum_common_t *) pie;
  255.     gx_image_enum_common_init(*pinfo, (const gs_data_image_t *) pim,
  256.                   (context == PDF_IMAGE_TYPE3_MASK ?
  257.                    &pdf_image_object_enum_procs :
  258.                    &pdf_image_enum_procs),
  259.                   (gx_device *)pdev, num_components, format);
  260.     pie->memory = mem;
  261.     width = rect.q.x - rect.p.x;
  262.     pie->width = width;
  263.     height = rect.q.y - rect.p.y;
  264.     pie->bits_per_pixel =
  265.     pim->BitsPerComponent * num_components / pie->num_planes;
  266.     pie->rows_left = height;
  267.     nbytes = (((ulong) pie->width * pie->bits_per_pixel + 7) >> 3) *
  268.     pie->num_planes * pie->rows_left;
  269.     in_line &= nbytes <= MAX_INLINE_IMAGE_BYTES;
  270.     if (rect.p.x != 0 || rect.p.y != 0 ||
  271.     rect.q.x != pim->Width || rect.q.y != pim->Height ||
  272.     (is_mask ? pim->CombineWithColor :
  273.      pdf_color_space(pdev, &cs_value, pcs,
  274.              (in_line ? &pdf_color_space_names_short :
  275.               &pdf_color_space_names), in_line) < 0)
  276.     ) {
  277.     gs_free_object(mem, pie, "pdf_begin_image");
  278.     goto nyi;
  279.     }
  280.     pdf_put_clip_path(pdev, pcpath);
  281.     if (pmat == 0)
  282.     pmat = &ctm_only(pis);
  283.     {
  284.     gs_matrix mat;
  285.     gs_matrix bmat;
  286.     int code;
  287.  
  288.     pdf_make_bitmap_matrix(&bmat, -rect.p.x, -rect.p.y,
  289.                    pim->Width, pim->Height, height);
  290.     if ((code = gs_matrix_invert(&pim->ImageMatrix, &mat)) < 0 ||
  291.         (code = gs_matrix_multiply(&bmat, &mat, &mat)) < 0 ||
  292.         (code = gs_matrix_multiply(&mat, pmat, &pie->mat)) < 0
  293.         ) {
  294.         gs_free_object(mem, pie, "pdf_begin_image");
  295.         return code;
  296.     }
  297.     }
  298.     if ((code = pdf_begin_write_image(pdev, &pie->writer, gs_no_id, width,
  299.                       height, NULL, in_line)) < 0 ||
  300.     /****** pctm IS WRONG ******/
  301.     (code = psdf_setup_image_filters((gx_device_psdf *) pdev,
  302.                      &pie->writer.binary, &image.pixel,
  303.                      pmat, pis)) < 0 ||
  304.     (code = pdf_begin_image_data(pdev, &pie->writer,
  305.                      (const gs_pixel_image_t *)&image,
  306.                      &cs_value)) < 0
  307.     )
  308.     return code;
  309.     return 0;
  310.  nyi:
  311.     return gx_default_begin_typed_image
  312.     ((gx_device *)pdev, pis, pmat, pic, prect, pdcolor, pcpath, mem,
  313.      pinfo);
  314. }
  315. int
  316. gdev_pdf_begin_typed_image(gx_device * dev, const gs_imager_state * pis,
  317.                const gs_matrix *pmat, const gs_image_common_t *pic,
  318.                const gs_int_rect * prect,
  319.                const gx_drawing_color * pdcolor,
  320.                const gx_clip_path * pcpath, gs_memory_t * mem,
  321.                gx_image_enum_common_t ** pinfo)
  322. {
  323.     return pdf_begin_typed_image((gx_device_pdf *)dev, pis, pmat, pic, prect,
  324.                  pdcolor, pcpath, mem, pinfo,
  325.                  PDF_IMAGE_DEFAULT);
  326. }
  327.  
  328. /* ---------------- All images ---------------- */
  329.  
  330. /* Process the next piece of an image. */
  331. private int
  332. pdf_image_plane_data(gx_image_enum_common_t * info,
  333.              const gx_image_plane_t * planes, int height,
  334.              int *rows_used)
  335. {
  336.     gx_device_pdf *pdev = (gx_device_pdf *)info->dev;
  337.     pdf_image_enum *pie = (pdf_image_enum *) info;
  338.     int h = height;
  339.     int y;
  340.     /****** DOESN'T HANDLE IMAGES WITH VARYING WIDTH PER PLANE ******/
  341.     uint width_bits = pie->width * pie->plane_depths[0];
  342.     /****** DOESN'T HANDLE NON-ZERO data_x CORRECTLY ******/
  343.     uint bcount = (width_bits + 7) >> 3;
  344.     uint ignore;
  345.     int nplanes = pie->num_planes;
  346.     stream *s = pdev->streams.strm;
  347.     long pos = stell(s);
  348.     int code;
  349.     int status = 0;
  350.  
  351.     if (h > pie->rows_left)
  352.     h = pie->rows_left;
  353.     pie->rows_left -= h;
  354.     for (y = 0; y < h; ++y) {
  355.     if (nplanes > 1) {
  356.         /*
  357.          * We flip images in blocks, and each block except the last one
  358.          * must contain an integral number of pixels.  The easiest way
  359.          * to meet this condition is for all blocks except the last to
  360.          * be a multiple of 3 source bytes (guaranteeing an integral
  361.          * number of 1/2/4/8/12-bit samples), i.e., 3*nplanes flipped
  362.          * bytes.  This requires a buffer of at least
  363.          * 3*GS_IMAGE_MAX_COMPONENTS bytes.
  364.          */
  365.         int pi;
  366.         uint count = bcount;
  367.         uint offset = 0;
  368. #define ROW_BYTES max(200 /*arbitrary*/, 3 * GS_IMAGE_MAX_COMPONENTS)
  369.         const byte *bit_planes[GS_IMAGE_MAX_COMPONENTS];
  370.         int block_bytes = ROW_BYTES / (3 * nplanes) * 3;
  371.         byte row[ROW_BYTES];
  372.  
  373.         for (pi = 0; pi < nplanes; ++pi)
  374.         bit_planes[pi] = planes[pi].data + planes[pi].raster * y;
  375.         while (count) {
  376.         uint flip_count;
  377.         uint flipped_count;
  378.  
  379.         if (count >= block_bytes) {
  380.             flip_count = block_bytes;
  381.             flipped_count = block_bytes * nplanes;
  382.         } else {
  383.             flip_count = count;
  384.             flipped_count =
  385.             (width_bits % (block_bytes * 8) * nplanes + 7) >> 3;
  386.         }
  387.         image_flip_planes(row, bit_planes, offset, flip_count,
  388.                   nplanes, pie->plane_depths[0]);
  389.         status = sputs(pie->writer.binary.strm, row, flipped_count,
  390.                    &ignore);
  391.         if (status < 0)
  392.             break;
  393.         offset += flip_count;
  394.         count -= flip_count;
  395.         }
  396.     } else {
  397.         status = sputs(pie->writer.binary.strm,
  398.                planes[0].data + planes[0].raster * y, bcount,
  399.                &ignore);
  400.     }
  401.     if (status < 0)
  402.         break;
  403.     }
  404.     *rows_used = h;
  405.     if (status < 0)
  406.     return_error(gs_error_ioerror);
  407.     code = cos_stream_add_since(pie->writer.data, pos);
  408.     return (code < 0 ? code : !pie->rows_left);
  409. #undef ROW_BYTES
  410. }
  411.  
  412. /* Clean up by releasing the buffers. */
  413. private int
  414. pdf_image_end_image_data(gx_image_enum_common_t * info, bool draw_last,
  415.              bool do_image)
  416. {
  417.     gx_device_pdf *pdev = (gx_device_pdf *)info->dev;
  418.     pdf_image_enum *pie = (pdf_image_enum *)info;
  419.     int height = pie->writer.height;
  420.     int data_height = height - pie->rows_left;
  421.     int code;
  422.  
  423.     if (pie->writer.pres)
  424.     ((pdf_x_object_t *)pie->writer.pres)->data_height = data_height;
  425.     else
  426.     pdf_put_image_matrix(pdev, &pie->mat,
  427.                  (height == 0 || data_height == 0 ? 1.0 :
  428.                   (double)data_height / height));
  429.     code = pdf_end_image_binary(pdev, &pie->writer, data_height);
  430.     if (code < 0)
  431.     return code;
  432.     code = pdf_end_write_image(pdev, &pie->writer);
  433.     switch (code) {
  434.     default:
  435.     return code;    /* error */
  436.     case 1:
  437.     code = 0;
  438.     break;
  439.     case 0:
  440.     if (do_image)
  441.         code = pdf_do_image(pdev, pie->writer.pres, &pie->mat, true);
  442.     }
  443.     gs_free_object(pie->memory, pie, "pdf_end_image");
  444.     return code;
  445. }
  446.  
  447. /* End a normal image, drawing it. */
  448. private int
  449. pdf_image_end_image(gx_image_enum_common_t * info, bool draw_last)
  450. {
  451.     return pdf_image_end_image_data(info, draw_last, true);
  452. }
  453.  
  454. /* ---------------- Type 3/3x images ---------------- */
  455.  
  456. /*
  457.  * For both types of masked images, we create temporary dummy (null) devices
  458.  * that forward the begin_typed_image call to the implementation above.
  459.  */
  460. private int
  461. pdf_make_mxd(gx_device **pmxdev, gx_device *tdev, gs_memory_t *mem)
  462. {
  463.     gx_device *fdev;
  464.     int code = gs_copydevice(&fdev, (const gx_device *)&gs_null_device, mem);
  465.  
  466.     if (code < 0)
  467.     return code;
  468.     gx_device_set_target((gx_device_forward *)fdev, tdev);
  469.     *pmxdev = fdev;
  470.     return 0;
  471. }
  472.  
  473. /* End the mask of an ImageType 3 image, not drawing it. */
  474. private int
  475. pdf_image_end_image_object(gx_image_enum_common_t * info, bool draw_last)
  476. {
  477.     return pdf_image_end_image_data(info, draw_last, false);
  478. }
  479.  
  480. /* ---------------- Type 3 images ---------------- */
  481.  
  482. /* Implement the mask image device. */
  483. private dev_proc_begin_typed_image(pdf_mid_begin_typed_image);
  484. private int
  485. pdf_image3_make_mid(gx_device **pmidev, gx_device *dev, int width, int height,
  486.             gs_memory_t *mem)
  487. {
  488.     int code = pdf_make_mxd(pmidev, dev, mem);
  489.  
  490.     if (code < 0)
  491.     return code;
  492.     set_dev_proc(*pmidev, begin_typed_image, pdf_mid_begin_typed_image);
  493.     return 0;
  494. }
  495. private int
  496. pdf_mid_begin_typed_image(gx_device * dev, const gs_imager_state * pis,
  497.               const gs_matrix *pmat, const gs_image_common_t *pic,
  498.               const gs_int_rect * prect,
  499.               const gx_drawing_color * pdcolor,
  500.               const gx_clip_path * pcpath, gs_memory_t * mem,
  501.               gx_image_enum_common_t ** pinfo)
  502. {
  503.     /* The target of the null device is the pdfwrite device. */
  504.     gx_device_pdf *const pdev = (gx_device_pdf *)
  505.     ((gx_device_null *)dev)->target;
  506.     int code = pdf_begin_typed_image
  507.     (pdev, pis, pmat, pic, prect, pdcolor, pcpath, mem, pinfo,
  508.      PDF_IMAGE_TYPE3_MASK);
  509.  
  510.     if (code < 0)
  511.     return code;
  512.     if ((*pinfo)->procs != &pdf_image_object_enum_procs) {
  513.     /* We couldn't handle the mask image.  Bail out. */
  514.     /* (This is never supposed to happen.) */
  515.     return_error(gs_error_rangecheck);
  516.     }
  517.     return code;
  518. }
  519.  
  520. /* Implement the mask clip device. */
  521. private int
  522. pdf_image3_make_mcde(gx_device *dev, const gs_imager_state *pis,
  523.              const gs_matrix *pmat, const gs_image_common_t *pic,
  524.              const gs_int_rect *prect, const gx_drawing_color *pdcolor,
  525.              const gx_clip_path *pcpath, gs_memory_t *mem,
  526.              gx_image_enum_common_t **pinfo,
  527.              gx_device **pmcdev, gx_device *midev,
  528.              gx_image_enum_common_t *pminfo,
  529.              const gs_int_point *origin)
  530. {
  531.     int code = pdf_make_mxd(pmcdev, midev, mem);
  532.     pdf_image_enum *pmie;
  533.     pdf_image_enum *pmce;
  534.     cos_stream_t *pmcs;
  535.  
  536.     if (code < 0)
  537.     return code;
  538.     code = pdf_begin_typed_image
  539.     ((gx_device_pdf *)dev, pis, pmat, pic, prect, pdcolor, pcpath, mem,
  540.      pinfo, PDF_IMAGE_TYPE3_DATA);
  541.     if (code < 0)
  542.     return code;
  543.     /* Add the /Mask entry to the image dictionary. */
  544.     if ((*pinfo)->procs != &pdf_image_enum_procs) {
  545.     /* We couldn't handle the image.  Bail out. */
  546.     gx_image_end(*pinfo, false);
  547.     gs_free_object(mem, *pmcdev, "pdf_image3_make_mcde");
  548.     return_error(gs_error_rangecheck);
  549.     }
  550.     pmie = (pdf_image_enum *)pminfo;
  551.     pmce = (pdf_image_enum *)(*pinfo);
  552.     pmcs = (cos_stream_t *)pmce->writer.pres->object;
  553.     return cos_dict_put_c_key_object(cos_stream_dict(pmcs), "/Mask",
  554.                      pmie->writer.pres->object);
  555. }
  556.  
  557. /* ---------------- Type 3x images ---------------- */
  558.  
  559. /* Implement the mask image device. */
  560. private int
  561. pdf_image3x_make_mid(gx_device **pmidev, gx_device *dev, int width, int height,
  562.              int depth, gs_memory_t *mem)
  563. {
  564.     int code = pdf_make_mxd(pmidev, dev, mem);
  565.  
  566.     if (code < 0)
  567.     return code;
  568.     set_dev_proc(*pmidev, begin_typed_image, pdf_mid_begin_typed_image);
  569.     return 0;
  570. }
  571.  
  572. /* Implement the mask clip device. */
  573. private int
  574. pdf_image3x_make_mcde(gx_device *dev, const gs_imager_state *pis,
  575.               const gs_matrix *pmat, const gs_image_common_t *pic,
  576.               const gs_int_rect *prect,
  577.               const gx_drawing_color *pdcolor,
  578.               const gx_clip_path *pcpath, gs_memory_t *mem,
  579.               gx_image_enum_common_t **pinfo,
  580.               gx_device **pmcdev, gx_device *midev[2],
  581.               gx_image_enum_common_t *pminfo[2],
  582.               const gs_int_point origin[2],
  583.               const gs_image3x_t *pim)
  584. {
  585.     int code;
  586.     pdf_image_enum *pmie;
  587.     pdf_image_enum *pmce;
  588.     cos_stream_t *pmcs;
  589.     int i;
  590.     const gs_image3x_mask_t *pixm;
  591.  
  592.     if (midev[0]) {
  593.     if (midev[1])
  594.         return_error(gs_error_rangecheck);
  595.     i = 0, pixm = &pim->Opacity;
  596.     } else if (midev[1])
  597.     i = 1, pixm = &pim->Shape;
  598.     else
  599.     return_error(gs_error_rangecheck);
  600.     code = pdf_make_mxd(pmcdev, midev[i], mem);
  601.     if (code < 0)
  602.     return code;
  603.     code = pdf_begin_typed_image
  604.     ((gx_device_pdf *)dev, pis, pmat, pic, prect, pdcolor, pcpath, mem,
  605.      pinfo, PDF_IMAGE_TYPE3_DATA);
  606.     if (code < 0)
  607.     return code;
  608.     if ((*pinfo)->procs != &pdf_image_enum_procs) {
  609.     /* We couldn't handle the image.  Bail out. */
  610.     gx_image_end(*pinfo, false);
  611.     gs_free_object(mem, *pmcdev, "pdf_image3x_make_mcde");
  612.     return_error(gs_error_rangecheck);
  613.     }
  614.     pmie = (pdf_image_enum *)pminfo[i];
  615.     pmce = (pdf_image_enum *)(*pinfo);
  616.     pmcs = (cos_stream_t *)pmce->writer.pres->object;
  617.     /*
  618.      * Add the SMask entry to the image dictionary, and, if needed,
  619.      * the Matte entry to the mask dictionary.
  620.      */
  621.     if (pixm->has_Matte) {
  622.     int num_components =
  623.         gs_color_space_num_components(pim->ColorSpace);
  624.  
  625.     code = cos_dict_put_c_key_floats(
  626.                 (cos_dict_t *)pmie->writer.pres->object,
  627.                 "/Matte", pixm->Matte,
  628.                 num_components);
  629.     if (code < 0)
  630.         return code;
  631.     }
  632.     return cos_dict_put_c_key_object(cos_stream_dict(pmcs), "/SMask",
  633.                      pmie->writer.pres->object);
  634. }
  635.